/*!
 * screenfull
 * v5.2.0 - 2021-11-03
 * https://github.com/sindresorhus/screenfull
 *
 * (c) Sindre Sorhus; MIT License
 */

(function () {
  "use strict";

  var document =
    typeof window !== "undefined" && typeof window.document !== "undefined"
      ? window.document
      : {};
  var isCommonjs = typeof module !== "undefined" && module.exports;

  var fn = (function () {
    var val;

    var fnMap = [
      [
        "requestFullscreen",
        "exitFullscreen",
        "fullscreenElement",
        "fullscreenEnabled",
        "fullscreenchange",
        "fullscreenerror",
      ],
      // New WebKit
      [
        "webkitRequestFullscreen",
        "webkitExitFullscreen",
        "webkitFullscreenElement",
        "webkitFullscreenEnabled",
        "webkitfullscreenchange",
        "webkitfullscreenerror",
      ],
      // Old WebKit
      [
        "webkitRequestFullScreen",
        "webkitCancelFullScreen",
        "webkitCurrentFullScreenElement",
        "webkitCancelFullScreen",
        "webkitfullscreenchange",
        "webkitfullscreenerror",
      ],
      [
        "mozRequestFullScreen",
        "mozCancelFullScreen",
        "mozFullScreenElement",
        "mozFullScreenEnabled",
        "mozfullscreenchange",
        "mozfullscreenerror",
      ],
      [
        "msRequestFullscreen",
        "msExitFullscreen",
        "msFullscreenElement",
        "msFullscreenEnabled",
        "MSFullscreenChange",
        "MSFullscreenError",
      ],
    ];

    var i = 0;
    var l = fnMap.length;
    var ret = {};

    for (; i < l; i++) {
      val = fnMap[i];
      if (val && val[1] in document) {
        for (i = 0; i < val.length; i++) {
          ret[fnMap[0][i]] = val[i];
        }
        return ret;
      }
    }

    return false;
  })();

  var eventNameMap = {
    change: fn.fullscreenchange,
    error: fn.fullscreenerror,
  };

  var screenfull = {
    request: function (element, options) {
      return new Promise(
        function (resolve, reject) {
          var onFullScreenEntered = function () {
            this.off("change", onFullScreenEntered);
            resolve();
          }.bind(this);

          this.on("change", onFullScreenEntered);

          element = element || document.documentElement;

          var returnPromise = element[fn.requestFullscreen](options);

          if (returnPromise instanceof Promise) {
            returnPromise.then(onFullScreenEntered).catch(reject);
          }
        }.bind(this)
      );
    },
    exit: function () {
      return new Promise(
        function (resolve, reject) {
          if (!this.isFullscreen) {
            resolve();
            return;
          }

          var onFullScreenExit = function () {
            this.off("change", onFullScreenExit);
            resolve();
          }.bind(this);

          this.on("change", onFullScreenExit);

          var returnPromise = document[fn.exitFullscreen]();

          if (returnPromise instanceof Promise) {
            returnPromise.then(onFullScreenExit).catch(reject);
          }
        }.bind(this)
      );
    },
    toggle: function (element, options) {
      return this.isFullscreen ? this.exit() : this.request(element, options);
    },
    onchange: function (callback) {
      this.on("change", callback);
    },
    onerror: function (callback) {
      this.on("error", callback);
    },
    on: function (event, callback) {
      var eventName = eventNameMap[event];
      if (eventName) {
        document.addEventListener(eventName, callback, false);
      }
    },
    off: function (event, callback) {
      var eventName = eventNameMap[event];
      if (eventName) {
        document.removeEventListener(eventName, callback, false);
      }
    },
    raw: fn,
  };

  if (!fn) {
    if (isCommonjs) {
      module.exports = { isEnabled: false };
    } else {
      window.screenfull = { isEnabled: false };
    }

    return;
  }

  Object.defineProperties(screenfull, {
    isFullscreen: {
      get: function () {
        return Boolean(document[fn.fullscreenElement]);
      },
    },
    element: {
      enumerable: true,
      get: function () {
        return document[fn.fullscreenElement];
      },
    },
    isEnabled: {
      enumerable: true,
      get: function () {
        // Coerce to boolean in case of old WebKit
        return Boolean(document[fn.fullscreenEnabled]);
      },
    },
  });

  if (isCommonjs) {
    module.exports = screenfull;
  } else {
    window.screenfull = screenfull;
  }

  layui.define(function (exports) {
    exports("fullscreen", screenfull);
  });
})();
